home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet internetowy / Przegladarki internetowe / Mozilla Seamonkey 1.0.5 pl / seamonkey-1.0.5.pl-PL.win32.installer.exe / VENKMAN.XPI / bin / chrome / venkman.jar / content / venkman / view-manager.js < prev   
Encoding:
Text File  |  2004-04-18  |  47.8 KB  |  1,646 lines
  1. /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
  2.  *
  3.  * ***** BEGIN LICENSE BLOCK *****
  4.  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  5.  *
  6.  * The contents of this file are subject to the Mozilla Public License Version
  7.  * 1.1 (the "License"); you may not use this file except in compliance with
  8.  * the License. You may obtain a copy of the License at
  9.  * http://www.mozilla.org/MPL/
  10.  *
  11.  * Software distributed under the License is distributed on an "AS IS" basis,
  12.  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  13.  * for the specific language governing rights and limitations under the
  14.  * License.
  15.  *
  16.  * The Original Code is The JavaScript Debugger.
  17.  *
  18.  * The Initial Developer of the Original Code is
  19.  * Netscape Communications Corporation.
  20.  * Portions created by the Initial Developer are Copyright (C) 1998
  21.  * the Initial Developer. All Rights Reserved.
  22.  *
  23.  * Contributor(s):
  24.  *   Robert Ginda, <rginda@netscape.com>, original author
  25.  *
  26.  * Alternatively, the contents of this file may be used under the terms of
  27.  * either the GNU General Public License Version 2 or later (the "GPL"), or
  28.  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  29.  * in which case the provisions of the GPL or the LGPL are applicable instead
  30.  * of those above. If you wish to allow use of your version of this file only
  31.  * under the terms of either the GPL or the LGPL, and not to allow others to
  32.  * use your version of this file under the terms of the MPL, indicate your
  33.  * decision by deleting the provisions above and replace them with the notice
  34.  * and other provisions required by the GPL or the LGPL. If you do not delete
  35.  * the provisions above, a recipient may use your version of this file under
  36.  * the terms of any one of the MPL, the GPL or the LGPL.
  37.  *
  38.  * ***** END LICENSE BLOCK ***** */
  39.  
  40. const VMGR_VURL_SCHEME = "x-vloc:";
  41. const VMGR_SCHEME_LEN  = VMGR_VURL_SCHEME.length;
  42.  
  43. const VMGR_HIDDEN      = "hidden";
  44. const VMGR_NEW         = "new";
  45. const VMGR_MAINWINDOW  = "mainwindow";
  46. const VMGR_GUTTER      = "gutter";
  47.  
  48. const VMGR_VURL_HIDDEN     = VMGR_VURL_SCHEME + "/" + VMGR_HIDDEN;
  49. const VMGR_VURL_NEW        = VMGR_VURL_SCHEME + "/" + VMGR_NEW;
  50. const VMGR_VURL_MAINWINDOW = VMGR_VURL_SCHEME + "/" + VMGR_MAINWINDOW;
  51. const VMGR_VURL_GUTTER     = VMGR_VURL_MAINWINDOW + "/gutter";
  52. const VMGR_DEFAULT_CONTAINER = "initial-container";
  53.  
  54. var VMGR_GUTTER_CONTAINER = VMGR_VURL_MAINWINDOW + "?target=container&" +
  55.     "id=" + VMGR_GUTTER + "&type=vertical";
  56.  
  57. function ViewManager(commandManager, mainWindow)
  58. {
  59.     this.commandManager = commandManager;    
  60.     this.multiMoveDepth = 0;
  61.     this.floaterSequence = 0;
  62.     this.containerSequence = 0;
  63.     this.dirtyContainers = new Object();
  64.     this.windows = new Object();
  65.     this.mainWindow = mainWindow;
  66.     this.windows[VMGR_MAINWINDOW] = mainWindow;
  67.     this.views = new Object();
  68. }
  69.  
  70. ViewManager.prototype.realizeViews =
  71. function vmgr_realizeviews (views)
  72. {
  73.     for (var v in views)
  74.         this.realizeView(views[v]);
  75. }    
  76.  
  77. ViewManager.prototype.realizeView =
  78. function vmgr_realizeview (view)
  79. {
  80.     var entry;
  81.     var key = view.viewId;
  82.     this.views[key] = view;
  83.     if ("init" in view && typeof view.init == "function")
  84.         view.init();
  85.     
  86.     var toggleName = "toggle-" + key;
  87.     if (!(key in this.commandManager.commands))
  88.     {
  89.         entry = [toggleName, "toggle-view " + key, CMD_CONSOLE];
  90.         
  91.         if ("cmdary" in view)
  92.             view.cmdary.unshift(entry);
  93.         else
  94.             view.cmdary = [entry];
  95.     }
  96.     
  97.     if ("cmdary" in view)
  98.     {
  99.         var commands = this.commandManager.defineCommands(view.cmdary);
  100.         for (var i in this.windows)
  101.             this.commandManager.installKeys (this.windows[i].document,
  102.                                              commands);
  103.         view.commands = commands;
  104.     }
  105.     if ("hooks" in view)
  106.         this.commandManager.addHooks (view.hooks, key);
  107. }
  108.  
  109. ViewManager.prototype.unrealizeViews =
  110. function vmgr_unrealizeviews (views)
  111. {
  112.     for (var v in views)
  113.         this.unrealizeView(views[v]);
  114. }    
  115.  
  116. ViewManager.prototype.unrealizeView =
  117. function vmgr_unrealizeview (view)
  118. {
  119.     if ("commands" in view)
  120.         this.commandManager.uninstallKeys(view.commands);
  121.     if ("hooks" in view)
  122.         this.commandManager.removeHooks (view.hooks, view.viewId);
  123.  
  124.     if ("destroy" in view && typeof view.destroy == "function")
  125.         view.destroy();
  126.  
  127.     delete this.views[view.viewId];
  128. }
  129.  
  130. ViewManager.prototype.startMultiMove =
  131. function vmrg_startmm()
  132. {
  133.     ++this.multiMoveDepth;
  134. }
  135.  
  136. ViewManager.prototype.endMultiMove =
  137. function vmrg_endmm()
  138. {
  139.     --this.multiMoveDepth;
  140.  
  141.     ASSERT(this.multiMoveDepth >= 0, "mismatched multi move calls: " +
  142.            this.multiMoveDepth);
  143.  
  144.     var container;
  145.     
  146.     if (!this.multiMoveDepth)
  147.     {
  148.         // close any empty windows that may have been left open during the
  149.         // multi move.
  150.         for (var w in this.windows)
  151.         {
  152.             if (w != VMGR_MAINWINDOW)
  153.             {
  154.                 var window = this.windows[w];
  155.                 container = 
  156.                     window.document.getElementById(VMGR_DEFAULT_CONTAINER);
  157.                 if (container && container.viewCount == 0)
  158.                     window.close();
  159.             }
  160.         }
  161.  
  162.         // deal with any single child tab containers too
  163.         for (var viewId in this.views)
  164.         {
  165.             var view = this.views[viewId];
  166.             if ("currentContent" in view && view.currentContent)
  167.             {
  168.                 container = view.currentContent.parentNode;
  169.                 if (container.getAttribute("type") == "tab" &&
  170.                     container.viewCount == 1)
  171.                 {
  172.                     var parentLocation = this.computeLocation(container);
  173.                     container.viewCount = 0;
  174.                     this.moveView(parentLocation, viewId);
  175.                     container.parentNode.removeChild(container);
  176.                 }
  177.             }
  178.         }
  179.     }
  180. }
  181.     
  182. ViewManager.prototype.getWindowById =
  183. function vmgr_getwindow (windowId)
  184. {
  185.     if (windowId in this.windows)
  186.         return this.windows[windowId];
  187.  
  188.     return null;
  189. }
  190.  
  191. ViewManager.prototype.createWindow =
  192. function vmgr_createwindow (windowId, cb)
  193. {
  194.     var viewManager = this;
  195.     
  196.     function onWindowLoaded (window)
  197.     {
  198.         var cm = viewManager.commandManager;
  199.         cm.installKeys (window.document, cm.commands);
  200.         if (typeof cb == "function")
  201.             cb(window);
  202.     };
  203.     
  204.     if (!ASSERT(!(windowId in this.windows), "window " + windowId +
  205.                 " already exists"))
  206.     {
  207.         return null;
  208.     }
  209.     
  210.     var win = openDialog ("chrome://venkman/content/venkman-floater.xul?id=" +
  211.                           encodeURIComponent(windowId), "_blank",
  212.                           "chrome,menubar,toolbar,resizable,dialog=no",
  213.                           onWindowLoaded);
  214.     this.windows[windowId] = win;
  215.     return win;
  216. }
  217.  
  218. ViewManager.prototype.destroyWindows =
  219. function vmgr_destroywindows ()
  220. {
  221.     this.startMultiMove();
  222.     
  223.     for (var w in this.windows)
  224.     {
  225.         if (w == VMGR_MAINWINDOW)
  226.             this.destroyWindow(w);
  227.         else
  228.             this.windows[w].close();
  229.     }
  230.     
  231.     this.endMultiMove();
  232. }
  233.  
  234. ViewManager.prototype.destroyWindow =
  235. function vmgr_destroywindow (windowId)
  236. {
  237.     if (!ASSERT(windowId in this.windows, "unknown window id"))
  238.         return;
  239.  
  240.     var document = this.windows[windowId].document;
  241.     
  242.     for (var viewId in this.views)
  243.     {
  244.         try
  245.         {
  246.             var view = this.views[viewId];
  247.             
  248.             if ("currentContent" in view &&
  249.                 view.currentContent.ownerDocument == document)
  250.             {
  251.                 this.moveViewURL(VMGR_VURL_HIDDEN, viewId);
  252.             }
  253.         }
  254.         catch (ex)
  255.         {
  256.             dd ("caught exception while moving view ``" + ex + "''");
  257.         }
  258.     }
  259.  
  260.     var container = document.getElementById (VMGR_DEFAULT_CONTAINER);
  261.     var child = container.firstChild;
  262.     while (child)
  263.     {
  264.         var next = child.nextSibling;
  265.         container.removeChild (child);
  266.         child = next;
  267.     }
  268.  
  269.     if (windowId != VMGR_MAINWINDOW)
  270.         delete this.windows[windowId];
  271. }
  272.  
  273. ViewManager.prototype.destroyContainer =
  274. function vmgr_destroycontainer (container)
  275. {
  276.     content = container.firstChild;
  277.     
  278.     while (content)
  279.     {
  280.         if (content.hasAttribute("grout"))
  281.         {
  282.             content.parentNode.removeChild(content);
  283.         }
  284.         else
  285.         {
  286.             if (content.localName == "viewcontainer")
  287.             {
  288.                 this.destroyContainer(content);
  289.             }
  290.             else
  291.             {
  292.                 var viewId = content.getAttribute("id");
  293.                 this.moveViewURL(VMGR_VURL_HIDDEN, viewId);
  294.             }
  295.         }
  296.         
  297.         content = container.firstChild;
  298.     }
  299.     
  300.     container.parentNode.removeChild(container);
  301. }
  302.                 
  303. ViewManager.prototype.changeContainer =
  304. function vmgr_changecontainer (container, newType)
  305. {
  306.     if (!ASSERT(newType != container.getAttribute("type"),
  307.                 "requested useless change, ``" + newType + "''"))
  308.     {
  309.         return;
  310.     }
  311.     
  312.     this.hideContainer(container);
  313.     container.setAttribute("type", newType);
  314.     this.showContainer(container);
  315.     
  316.     this.groutContainer(container);
  317. }
  318.     
  319. ViewManager.prototype.createContainer =
  320. function vmgr_createcontainer (parsedLocation, containerId, type)
  321. {
  322.     if (!type)
  323.         type = "vertical";
  324.     
  325.     var parentContainer = this.getLocation(parsedLocation);
  326.     
  327.     if (!ASSERT(parentContainer, "location is hidden or does not exist"))
  328.         return null;
  329.  
  330.     var document = parentContainer.ownerDocument;
  331.     var container = document.createElement("viewcontainer");
  332.     container.setAttribute ("id", containerId);
  333.     container.setAttribute ("flex", "1");
  334.     container.setAttribute ("type", type);
  335.     if ("width" in parsedLocation)
  336.         container.setAttribute ("width", parsedLocation.width);
  337.     if ("height" in parsedLocation)
  338.         container.setAttribute ("height", parsedLocation.height);
  339.     container.setAttribute ("collapsed", "true");
  340.     var before;
  341.     if ("before" in parsedLocation)
  342.         before = getChildById(parentContainer, parsedLocation.before);
  343.     parentContainer.insertBefore(container, before);
  344.     this.groutContainer(parentContainer);
  345.  
  346.     return container;
  347. }
  348.  
  349. /*
  350.  * x-vloc:/<window-id>[/<container-id>][?<option>[&<option>...]]
  351.  *
  352.  * <option> is one of...
  353.  *   before=<view-id>
  354.  *   type=(horizontal|vertical|tab)
  355.  *   id=(<view-id>|<container-id>)
  356.  *   target=(view|container)
  357.  *   width=<number>
  358.  *   height=<number>
  359.  *
  360.  * parseResult
  361.  *  +- url
  362.  *  +- windowId
  363.  *  +- containerId
  364.  *  +- <option>
  365.  *  +- ...
  366.  */
  367.  
  368. ViewManager.prototype.parseLocation =
  369. function vmgr_parselocation (locationURL)
  370. {
  371.     var parseResult;
  372.     var ary;
  373.     
  374.     if (locationURL.indexOf(VMGR_VURL_SCHEME) != 0)
  375.         return null;
  376.     
  377.     ary =
  378.         locationURL.substr(VMGR_SCHEME_LEN).match(/([^\/?]+)(?:\/([^\/?]+))?/);
  379.     if (!ary)
  380.         return null;
  381.  
  382.     parseResult = {
  383.         url: locationURL,
  384.         windowId: ary[1],
  385.         containerId: arrayHasElementAt(ary, 2) ? ary[2] : VMGR_DEFAULT_CONTAINER
  386.     };
  387.  
  388.     var rest = RegExp.rightContext.substr(1);
  389.  
  390.     ary = rest.match(/([^&]+)/);
  391.  
  392.     while (ary)
  393.     {
  394.         rest = RegExp.rightContext.substr(1);
  395.         var assignment = ary[1];
  396.         ary = assignment.match(/(.+)=(.*)/);
  397.         if (ASSERT(ary, "error parsing ``" + assignment + "'' from " +
  398.                    locationURL))
  399.         {
  400.             /* only set the property the first time we see it */
  401.             if (arrayHasElementAt(ary, 2) && !(ary[1] in parseResult))
  402.                 parseResult[ary[1]] = ary[2];
  403.         }
  404.         ary = rest.match(/([^&]+)/);
  405.     }
  406.     
  407.     if (parseResult.windowId == VMGR_NEW)
  408.     {
  409.         var id = "floater-" + this.floaterSequence++;
  410.  
  411.         while (id in this.windows)
  412.             id = "floater-" + this.floaterSequence++;
  413.  
  414.         parseResult.windowId = id;
  415.     }
  416.  
  417.     //dd (dumpObjectTree(parseResult));
  418.     return parseResult;
  419. }
  420.  
  421. ViewManager.prototype.getWindowId =
  422. function getwindowid (window)
  423. {
  424.     for (var m in this.windows)
  425.     {
  426.         if (this.windows[m] == window)
  427.             return m;
  428.     }
  429.  
  430.     ASSERT (0, "unknown window");
  431.     return null;
  432. }   
  433.  
  434. ViewManager.prototype.getLayoutState =
  435. function vmgr_getlayout ()
  436. {
  437.     var ary = new Array();
  438.     
  439.     for (var w in this.windows)
  440.     {
  441.         var container = 
  442.             this.windows[w].document.getElementById (VMGR_DEFAULT_CONTAINER);
  443.         this.getContainerContents (container, true, ary);
  444.     }
  445.     
  446.     return ary;
  447. }        
  448.         
  449. ViewManager.prototype.getContainerContents =
  450. function vmgr_getcontents (container, recurse, ary)
  451. {
  452.     if (!ary)
  453.         ary = new Array();
  454.     var child = container.firstChild;
  455.     
  456.     while (child)
  457.     {
  458.         if (child.localName == "viewcontainer" && "viewCount" in child &&
  459.             child.viewCount > 0)
  460.         {
  461.             ary.push (this.computeLocation(child));
  462.             if (recurse)
  463.                 this.getContainerContents(child, true, ary);
  464.         }
  465.         else if (child.localName == "floatingview")
  466.         {
  467.             ary.push (this.computeLocation(child));
  468.         }
  469.         child = child.nextSibling;
  470.     }
  471.  
  472.     return ary;
  473. }
  474.  
  475. ViewManager.prototype.reconstituteVURLs =
  476. function vmgr_remake (ary, cb, startIndex, recalled)
  477. {
  478.     var viewManager = this;
  479.     
  480.     function onWindowLoaded (window)
  481.     {
  482.         viewManager.reconstituteVURLs (ary, cb, i, true);
  483.     };
  484.     
  485.     if (!startIndex)
  486.         startIndex = 0;
  487.  
  488.     if (!recalled)
  489.         this.startMultiMove();
  490.  
  491.     for (var i = startIndex; i < ary.length; ++i)
  492.     {
  493.         var parsedLocation = this.parseLocation (ary[i]);
  494.         if (!ASSERT(parsedLocation, "can't parse " + ary[i]) ||
  495.             !ASSERT("target" in parsedLocation, "no target in " + ary[i]) ||
  496.             !ASSERT("id" in parsedLocation, "no id in " + ary[i]))
  497.         {
  498.             continue;
  499.         }
  500.  
  501.         if (parsedLocation.target == "container")
  502.         {
  503.             if (!(parsedLocation.windowId in this.windows))
  504.             {
  505.                 //dd ("loading window " + parsedLocation.windowId);
  506.                 this.createWindow (parsedLocation.windowId, onWindowLoaded);
  507.                 return;
  508.             }
  509.                 
  510.             if (!ASSERT("type" in parsedLocation, "no type in " + ary[i]))
  511.                 parsedLocation.type = "vertical";
  512.             this.createContainer (parsedLocation, parsedLocation.id,
  513.                                   parsedLocation.type);
  514.         }
  515.         else if (parsedLocation.target == "view")
  516.         {
  517.             var height = ("height" in parsedLocation ?
  518.                          parsedLocation.height : null);
  519.             var width = ("width" in parsedLocation ?
  520.                          parsedLocation.width : null);
  521.             this.moveView (parsedLocation, parsedLocation.id, height, width);
  522.         }
  523.         else
  524.         {
  525.             ASSERT(0, "unknown target in " + ary[i]);
  526.         }
  527.     }
  528.  
  529.     if (typeof cb == "function")
  530.         cb();
  531.     
  532.     this.endMultiMove();
  533. }
  534.  
  535. ViewManager.prototype.computeLocation =
  536. function vmgr_computelocation (element)
  537. {
  538.     if (!ASSERT(element, "missig parameter"))
  539.         return null;
  540.     
  541.     if (!element.parentNode)
  542.         return VMGR_VURL_HIDDEN;
  543.     
  544.     var target;
  545.     var containerId;
  546.     var type;
  547.     
  548.     if (element.localName == "floatingview")
  549.     {
  550.         target = "view";
  551.         if (element.parentNode.localName != "viewcontainer")
  552.             containerId = VMGR_HIDDEN;
  553.         else
  554.             containerId = element.parentNode.getAttribute("id");
  555.     }
  556.     else if (element.localName == "viewcontainer")
  557.     {
  558.         target      = "container";
  559.         containerId = element.parentNode.getAttribute("id");
  560.         type        = element.getAttribute("type");
  561.     }
  562.     else
  563.     {
  564.         ASSERT(0, "can't get location for unknown element " +
  565.                element.localName);
  566.         return null;
  567.     }
  568.  
  569.     var before;
  570.     
  571.     if (containerId != VMGR_HIDDEN)
  572.     {
  573.         var beforeNode = element.nextSibling;
  574.         if (beforeNode)
  575.         {
  576.             if (beforeNode.hasAttribute("grout"))
  577.                 beforeNode = beforeNode.nextSibling;
  578.             
  579.             if (ASSERT(beforeNode, "nothing before the grout?"))
  580.                 before = beforeNode.getAttribute("id");
  581.         }
  582.     }
  583.  
  584.     var windowId = this.getWindowId(element.ownerWindow);
  585.     var id       = element.getAttribute("id");
  586.     var height   = element.getAttribute("height");
  587.     var width    = element.getAttribute("width");
  588.     var url      = VMGR_VURL_SCHEME + "/" + windowId + "/" + containerId +
  589.         "?target=" + target + "&id=" + id;
  590.     if (height)
  591.         url += "&height=" + height;
  592.     if (width)
  593.         url += "&width=" + width;
  594.     if (before)
  595.         url += "&before=" + before;
  596.     if (type)
  597.         url += "&type=" + type;
  598.         
  599.     var result = new String(url);
  600.     result.url = url;
  601.     result.windowId = windowId;
  602.     result.containerId = containerId;
  603.     result.target = target;
  604.     result.id = id;
  605.     result.height = height;
  606.     result.width = width;
  607.     result.before = before;
  608.     result.type = type;
  609.  
  610.     return result;
  611. }
  612.  
  613. ViewManager.prototype.locationExists =
  614. function vmgr_islocation (parsedLocation)
  615. {
  616.     if (parsedLocation.windowId == VMGR_HIDDEN)
  617.         return true;
  618.     
  619.     if (this.getLocation(parsedLocation))
  620.         return true;
  621.  
  622.     return false;
  623. }
  624.  
  625. ViewManager.prototype.getLocation =
  626. function vmgr_getlocation (parsedLocation)
  627. {
  628.     if (parsedLocation.windowId == VMGR_HIDDEN)
  629.     {
  630.         //dd ("getLocation: location is hidden");
  631.         return null;
  632.     }
  633.     
  634.     var window = this.getWindowById(parsedLocation.windowId);
  635.     if (!ASSERT(window, "unknown window id " + parsedLocation.windowId))
  636.         return false;
  637.  
  638.     if (!parsedLocation.containerId)
  639.         parsedLocation.containerId = VMGR_DEFAULT_CONTAINER;
  640.     
  641.     var container = window.document.getElementById(parsedLocation.containerId);
  642.     return container;
  643. }    
  644.  
  645. ViewManager.prototype.ensureLocation =
  646. function vmgr_ensurelocation (parsedLocation, cb)
  647. {
  648.     var viewManager = this;
  649.     
  650.     function onWindowLoaded (window)
  651.     {
  652.         var container = 
  653.             window.document.getElementById (parsedLocation.containerId);
  654.         if (!container && parsedLocation.containerId == VMGR_GUTTER)
  655.         {
  656.             viewManager.reconstituteVURLs ([VMGR_GUTTER_CONTAINER]);
  657.             container = 
  658.                 window.document.getElementById (parsedLocation.containerId);
  659.         }
  660.         cb (window, container);
  661.     };
  662.     
  663.     if (parsedLocation.windowId == VMGR_HIDDEN)
  664.     {
  665.         cb(null, null);
  666.         return;
  667.     }
  668.     
  669.     var window = this.getWindowById(parsedLocation.windowId);
  670.     if (window)
  671.     {
  672.         onWindowLoaded(window);
  673.         return;
  674.     }
  675.     
  676.     this.createWindow (parsedLocation.windowId, onWindowLoaded);
  677. }
  678.  
  679. /**
  680.  * This only half-assed affects the contents.  It calls the show/hide events
  681.  * on the contained views, but does not actually re-home the content.  This
  682.  * should only be used to quickly move views within the same window.
  683.  */
  684. ViewManager.prototype.showContainer =
  685. function vbgr_showctr (container, state)
  686. {
  687.     if (typeof state == "undefined")
  688.         state = true;
  689.     
  690.     var content = container.firstChild;
  691.     while (content)
  692.     {
  693.         if (content.localName == "floatingview")
  694.         {
  695.             var viewId = content.getAttribute("id");
  696.             if (!ASSERT(viewId in this.views, "unknown view"))
  697.             {
  698.                 content = content.nextSibling;
  699.                 continue;
  700.             }
  701.  
  702.             if (state)
  703.                 this.views[viewId].onShow();
  704.             else
  705.                 this.views[viewId].onHide();
  706.         }
  707.         else if (content.localName == "viewcontainer")
  708.         {
  709.             this.showContainer(content, state);
  710.         }
  711.  
  712.         content = content.nextSibling;
  713.     }
  714. }
  715.  
  716. ViewManager.prototype.hideContainer =
  717. function vbgr_hidectr (container)
  718. {
  719.     this.showContainer(container, false);
  720. }
  721.  
  722. ViewManager.prototype.moveContainer =
  723. function vmgr_movectr (parsedLocation, sourceContainer)
  724. {
  725.     var viewManager = this;
  726.     
  727.     function onLocationFound (window, container)
  728.     {
  729.         if (!window)
  730.         {
  731.             ASSERT(false, "not implemented");
  732.             return;
  733.             // everything gets hidden
  734.         }
  735.         
  736.         var beforeNode;
  737.         if ("before" in parsedLocation)
  738.             beforeNode = window.document.getElementById(parsedLocation.before);
  739.  
  740.         if (!container)
  741.         {
  742.             /* container does not exist. */
  743.             if (beforeNode)
  744.             {
  745.                 // if we know who it's supposed to be before, then drop it
  746.                 // there.
  747.                 container = beforeNode.parentNode;
  748.             }
  749.             else
  750.             {
  751.                 // otherwise, toss it in the gutter
  752.                 var gutterContainer = Clone(parsedLocation);
  753.                 gutterContainer.containerId = VMGR_GUTTER;
  754.                 container = viewManager.getLocation(gutterContainer);
  755.                 if (!container)
  756.                 {
  757.                     gutterContainer.containerId = VMGR_DEFAULT_CONTAINER;
  758.                     container = viewManager.createContainer(gutterContainer,
  759.                                                             VMGR_GUTTER,
  760.                                                             "vertical");
  761.                 }
  762.             }
  763.             if (!ASSERT(container, "can't locate default container"))
  764.                 return;
  765.         }
  766.         else if (beforeNode && beforeNode.parentNode != container)
  767.         {
  768.             //dd ("before is not in container");
  769.             /* container portion of url wins in a mismatch situation */
  770.             beforeNode = null;
  771.         }
  772.  
  773.         viewManager.hideContainer(sourceContainer);
  774.  
  775.         var previousParent = sourceContainer.parentNode;
  776.         previousParent.removeChild(sourceContainer);
  777.         viewManager.groutContainer(previousParent);
  778.  
  779.         dd ("beforeNode is " + (beforeNode ? beforeNode.getAttribute("id") :
  780.             null));
  781.         
  782.         container.insertBefore(sourceContainer, beforeNode);
  783.         viewManager.showContainer(sourceContainer);
  784.         viewManager.groutContainer(sourceContainer);
  785.     };
  786.  
  787.     var sourceLocation = this.computeLocation(sourceContainer);
  788.     if (!ASSERT (sourceLocation.windowId == parsedLocation.windowId,
  789.                  "moving containers between windows is not supported"))
  790.     {
  791.         return;
  792.     }
  793.     
  794.     this.ensureLocation (parsedLocation, onLocationFound);
  795. }
  796.  
  797. ViewManager.prototype.moveViewURL =
  798. function vmgr_moveurl (locationURL, viewId)
  799. {
  800.     var parsedLocation = this.parseLocation(locationURL);
  801.     if (!ASSERT(parsedLocation, "can't parse " + locationURL))
  802.         return;
  803.     
  804.     this.moveView(parsedLocation, viewId);
  805. }
  806.  
  807. ViewManager.prototype.moveView =
  808. function vmgr_move (parsedLocation, viewId, height, width)
  809. {
  810.     var viewManager = this;
  811.     
  812.     function moveContent (content, newParent, before)
  813.     {
  814.         if (!("originalParent" in content))
  815.         {
  816.             if (!ASSERT(content.parentNode, "no original parent to record"))
  817.                 return;
  818.             content.originalParent = content.parentNode;
  819.         }
  820.         
  821.         //dd ("OFF moveContent {");
  822.         
  823.         var previousParent = content.parentNode;
  824.         previousParent.removeChild(content);
  825.         if (previousParent.localName == "viewcontainer")
  826.             viewManager.groutContainer (previousParent);
  827.  
  828.         if (newParent)
  829.         {
  830.             //dd ("placing in new parent");
  831.             newParent.insertBefore (content, before);
  832.             viewManager.groutContainer (newParent);
  833.         }
  834.         else
  835.         {
  836.             //dd ("hiding");
  837.             content.originalParent.appendChild(content);
  838.             content.setAttribute ("containertype", "hidden");
  839.         }
  840.  
  841.         //dd ("}");
  842.     };
  843.  
  844.     function onLocationFound (window, container)
  845.     {
  846.         if (!window)
  847.         {
  848.             /* view needs to be hidden. */
  849.             if (currentContent)
  850.             {
  851.                 if ("onHide" in view)
  852.                     view.onHide();
  853.  
  854.                 if ("onViewRemoved" in view.currentContent.ownerWindow)
  855.                     view.currentContent.ownerWindow.onViewRemoved(view);
  856.  
  857.                 moveContent (view.currentContent, null);
  858.                 delete view.currentContent;
  859.             }
  860.             return;
  861.         }
  862.         
  863.         var content = window.document.getElementById(viewId);
  864.         if (!ASSERT(content, "no content for ``" + viewId + "'' found in " +
  865.                     parsedLocation.windowId))
  866.         {
  867.             return;
  868.         }
  869.  
  870.         var beforeNode;
  871.         if ("before" in parsedLocation)
  872.         {
  873.             beforeNode = window.document.getElementById(parsedLocation.before);
  874.             if (beforeNode &&
  875.                 beforeNode.parentNode.localName != "viewcontainer")
  876.             {
  877.                 beforeNode = null;
  878.             }
  879.         }
  880.         
  881.         if (!container)
  882.         {
  883.             /* container does not exist. */
  884.             if (beforeNode)
  885.             {
  886.                 // if we know who it's supposed to be before, then drop it
  887.                 // there.
  888.                 container = beforeNode.parentNode;
  889.             }
  890.             else
  891.             {
  892.                 // otherwise, toss it in the gutter
  893.                 var gutterContainer = Clone(parsedLocation);
  894.                 gutterContainer.containerId = VMGR_GUTTER;
  895.                 container = viewManager.getLocation(gutterContainer);
  896.                 if (!container)
  897.                 {
  898.                     gutterContainer.containerId = VMGR_DEFAULT_CONTAINER;
  899.                     container = viewManager.createContainer(gutterContainer,
  900.                                                             VMGR_GUTTER,
  901.                                                             "vertical");
  902.                 }
  903.             }
  904.             if (!ASSERT(container, "can't locate default container"))
  905.                 return;
  906.         }
  907.         else if (beforeNode && beforeNode.parentNode != container)
  908.         {
  909.             //dd ("before is not in container");
  910.             /* container portion of url wins in a mismatch situation */
  911.             beforeNode = null;
  912.         }   
  913.         
  914.         if (currentContent)
  915.         {
  916.             //dd ("have content");
  917.             /* view is already visible, fire an onHide().  If we're destined for
  918.              * a new document, return the current content to it's hiding place.
  919.              */
  920.             if (beforeNode == currentContent ||
  921.                 (currentContent.nextSibling == beforeNode &&
  922.                  container == currentContent.parentNode))
  923.             {
  924.                 /* unless we're already where we are supposed to be. */
  925.                 return;
  926.             }   
  927.             
  928.             if ("onHide" in view)
  929.                 view.onHide();
  930.  
  931.             if ("onViewRemoved" in currentContent.ownerWindow)
  932.                 currentContent.ownerWindow.onViewRemoved(view);
  933.  
  934.             if (currentContent != content)
  935.             {
  936.                 //dd ("returning content to home");
  937.                 moveContent (currentContent, null);
  938.             }
  939.         }        
  940.         
  941.         moveContent (content, container, beforeNode);
  942.         view.currentContent = content;
  943.         if (height)
  944.             content.setAttribute ("height", height);
  945.         if (width)
  946.             content.setAttribute ("width", width);
  947.         
  948.         if ("onShow" in view)
  949.             view.onShow();
  950.  
  951.         if ("onViewAdded" in window)
  952.             window.onViewAdded(view);
  953.     };
  954.  
  955.     var view = this.views[viewId];
  956.     var currentContent = ("currentContent" in view ?
  957.                           view.currentContent : null);
  958.     if (currentContent && currentContent.ownerWindow == this.mainWindow)
  959.         view.previousLocation = this.computeLocation(currentContent);
  960.  
  961.     this.ensureLocation (parsedLocation, onLocationFound);
  962. }
  963.  
  964. ViewManager.prototype.groutContainer =
  965. function vmgr_groutcontainer (container)
  966. {
  967.     if (!container.parentNode)
  968.         return;
  969.     
  970.     var type = container.getAttribute ("type");
  971.     
  972.     if (!ASSERT(type in this.groutFunctions, "unknown container type ``" +
  973.                 type + "''"))
  974.     {
  975.         return;
  976.     }
  977.  
  978.     if (!container.hasAttribute("grout-in-progress"))
  979.     {
  980.         container.setAttribute("grout-in-progress", "true");
  981.  
  982.         this.groutFunctions[type](this, container);
  983.  
  984.         var location = this.computeLocation(container);
  985.         if (location in this.dirtyContainers)
  986.             delete this.dirtyContainers[location];
  987.  
  988.         container.removeAttribute("grout-in-progress");
  989.     }
  990. }
  991.  
  992. ViewManager.prototype.groutFunctions = new Object();
  993.  
  994. ViewManager.prototype.groutFunctions["tab"] =
  995. function vmgr_grouttab (viewManager, container)
  996. {
  997.     function onTabClick(event)
  998.     {
  999.         var target = event.target;
  1000.         while (target && target.localName != "little-tab")
  1001.             target = target.parentNode;
  1002.             
  1003.         var index = target.getAttribute("index");
  1004.         container.deck.selectedIndex = index;
  1005.         for (var i = 0; i < container.tabs.childNodes.length; ++i)
  1006.             container.tabs.childNodes[i].removeAttribute("selected");
  1007.  
  1008.         container.tabs.childNodes[index].setAttribute("selected", "true");
  1009.     };
  1010.     
  1011.     function closeWindow (window)
  1012.     {
  1013.         window.close();
  1014.     };
  1015.     
  1016.     if (!ASSERT(container, "null container"))
  1017.         return;
  1018.  
  1019.     ASSERT(container.localName == "viewcontainer",
  1020.            "Attempt to grout something that is not a view container");
  1021.  
  1022.     var content = container.firstChild;
  1023.     var document = container.ownerDocument;
  1024.     container.viewCount = 0;
  1025.  
  1026.     var lastSelected = container.deck.selectedIndex;
  1027.  
  1028.     while (content)
  1029.     {
  1030.         var nextContent = content.nextSibling;
  1031.  
  1032.         if (content.hasAttribute("grout"))
  1033.         {
  1034.             container.removeChild(content);
  1035.         }
  1036.         else
  1037.         {
  1038.             var viewId = content.getAttribute("id");
  1039.  
  1040.             if (!ASSERT(content.localName != "viewcontainer",
  1041.                         "tab containers cannot contain other containers"))
  1042.             {
  1043.                 viewManager.destroyContainer(content);
  1044.                 content = nextContent;
  1045.                 continue;
  1046.             }
  1047.             
  1048.             if (!ASSERT(viewId in viewManager.views, "unknown view id ``" +
  1049.                         viewId + "''"))
  1050.             {
  1051.                 content = nextContent;
  1052.                 continue;
  1053.             }
  1054.             
  1055.             var view = viewManager.views[viewId];
  1056.             
  1057.             var tab = (container.viewCount >= container.tabs.childNodes.length)
  1058.                       ? null : container.tabs.childNodes[container.viewCount];
  1059.             var label;
  1060.             
  1061.             if (!tab || tab.hasAttribute("needinit"))
  1062.             {
  1063.                 if (!tab)
  1064.                     tab = document.createElement("little-tab");
  1065.                 else
  1066.                     tab.removeAttribute("needinit");
  1067.                 
  1068.                 tab.setAttribute("index", container.viewCount);
  1069.                 tab.setAttribute("flex", "1");
  1070.                 container.tabs.appendChild(tab);
  1071.                 tab.addEventListener("click", onTabClick, false);
  1072.             }
  1073.             
  1074.             tab.setAttribute("label", view.caption);
  1075.  
  1076.             ++container.viewCount;
  1077.         }
  1078.  
  1079.         content = nextContent;
  1080.     }
  1081.  
  1082.     if (container.parentNode.localName == "viewcontainer")
  1083.         viewManager.groutContainer(container.parentNode);
  1084.  
  1085.     if (container.viewCount == 0)
  1086.     {
  1087.         //dd ("tab container is empty, hiding");
  1088.         container.setAttribute("collapsed", "true");
  1089.         if (viewManager.multiMoveDepth == 0 &&
  1090.             container.parentNode.localName == "window" &&
  1091.             container.ownerWindow != viewManager.mainWindow &&
  1092.             !("isClosing" in container.ownerWindow) &&
  1093.             lastViewCount > 0)
  1094.         {
  1095.             setTimeout (closeWindow, 1, container.ownerWindow);
  1096.             //dd ("} no children, closing window");
  1097.         }
  1098.         return;
  1099.     }
  1100.     
  1101.     //dd ("unhiding tab container");
  1102.     container.removeAttribute("collapsed");
  1103.  
  1104.     if (container.viewCount == 1 && !viewManager.multiMoveDepth)
  1105.     {
  1106.         var parentLocation =
  1107.             viewManager.computeLocation(view.currentContent.parentNode);
  1108.         container.viewCount = 0;
  1109.         viewManager.moveView(parentLocation, viewId);
  1110.         container.parentNode.removeChild(container);
  1111.         return;
  1112.     }
  1113.     
  1114.     while (container.tabs.childNodes.length > container.viewCount)
  1115.         container.tabs.removeChild(container.tabs.lastChild);
  1116.  
  1117.     if (lastSelected >= container.viewCount)
  1118.         lastSelected = container.viewCount - 1;
  1119.  
  1120.     if (typeof lastSelected == "number" && lastSelected > 0)
  1121.         container.deck.selectedIndex = lastSelected;
  1122.     else
  1123.         container.tabs.firstChild.setAttribute("selected", "true");
  1124.     
  1125. }
  1126.  
  1127. ViewManager.prototype.groutFunctions["horizontal"] =
  1128. ViewManager.prototype.groutFunctions["vertical"] =
  1129. function vmgr_groutbox (viewManager, container)
  1130. {
  1131.     function closeWindow (window)
  1132.     {
  1133.         window.close();
  1134.     };
  1135.     
  1136.     function isContainerEmpty (container)
  1137.     {
  1138.         var rv = container.localName == "viewcontainer" && 
  1139.             "viewCount" in container && container.viewCount == 0;
  1140.         //dd ("isContainerEmpty: " + container.getAttribute("id") + ": " + rv);
  1141.         return rv;
  1142.     };
  1143.     
  1144.     if (!ASSERT(container, "null container"))
  1145.         return;
  1146.  
  1147.     if (!ASSERT(container.parentNode, "container has no parent ``" +
  1148.                 container.getAttribute("id") + "''"))
  1149.     {
  1150.         return;
  1151.     }
  1152.     
  1153.     ASSERT(container.localName == "viewcontainer",
  1154.            "Attempt to grout something that is not a view container");
  1155.  
  1156.     //dd ("OFF grouting: " + container.getAttribute("id") +" {");
  1157.  
  1158.     var lastViewCount = ("viewCount" in container) ? container.viewCount : 0;
  1159.     container.viewCount = 0;
  1160.     var doc = container.ownerDocument;
  1161.     var content = container.firstChild;
  1162.     var orient = container.getAttribute("type");
  1163.     
  1164.     var previousContent;
  1165.     var nextContent;
  1166.     
  1167.     while (content)
  1168.     {
  1169.         previousContent = content.previousSibling;
  1170.         nextContent = content.nextSibling;
  1171.  
  1172.         while (nextContent && nextContent.localName == "viewcontainer" &&
  1173.                isContainerEmpty(nextContent))
  1174.         {
  1175.             //skip over empty containers
  1176.             nextContent = nextContent.nextSibling;
  1177.         }
  1178.  
  1179.         while (previousContent &&
  1180.                previousContent.localName == "viewcontainer" &&
  1181.                isContainerEmpty(previousContent))
  1182.         {
  1183.             //skip over empty containers
  1184.             previousContent = previousContent.previousSibling;
  1185.         }
  1186.  
  1187.         if (content.hasAttribute("grout"))
  1188.         {
  1189.             if (!previousContent || !nextContent ||
  1190.                 previousContent.hasAttribute("grout") ||
  1191.                 nextContent.hasAttribute("grout") ||
  1192.                 isContainerEmpty(previousContent))
  1193.             {
  1194.                 container.removeChild(content);
  1195.             }
  1196.             else
  1197.             {
  1198.                 content.setAttribute("orient", orient);
  1199.             }
  1200.         }
  1201.         else
  1202.         {
  1203.             if (content.localName == "floatingview")
  1204.                 ++container.viewCount;
  1205.             else if (content.localName == "viewcontainer")
  1206.             {
  1207.                 if ("viewCount" in content)
  1208.                     container.viewCount += content.viewCount;
  1209.                 //else
  1210.                     //dd ("no viewCount in " + content.getAttribute("id"));
  1211.             }
  1212.  
  1213.             if (nextContent && !nextContent.hasAttribute("grout") &&
  1214.                 !isContainerEmpty(nextContent) && !isContainerEmpty(content))
  1215.             {
  1216.                 var collapse;
  1217.                 if (content.hasAttribute("splitter-collapse"))
  1218.                     collapse = content.getAttribute("splitter-collapse");
  1219.                 else
  1220.                     collapse = "after";
  1221.                 var split = doc.createElement("splitter");
  1222.                 split.setAttribute("grout", "true");
  1223.                 split.setAttribute("collapse", collapse);
  1224.                 split.appendChild(doc.createElement("grippy"));
  1225.                 container.insertBefore(split, nextContent);
  1226.             }
  1227.         }
  1228.         content = nextContent;
  1229.     }
  1230.  
  1231.     if (previousContent && previousContent.hasAttribute("grout") &&
  1232.         isContainerEmpty(previousContent.nextSibling))
  1233.     {
  1234.         container.removeChild(previousContent);
  1235.     }
  1236.             
  1237.  
  1238.     if (isContainerEmpty(container))
  1239.     {
  1240.         //dd ("container is empty, hiding");
  1241.         container.setAttribute("collapsed", "true");
  1242.         if (viewManager.multiMoveDepth == 0 &&
  1243.             container.parentNode.localName == "window" &&
  1244.             container.ownerWindow != viewManager.mainWindow &&
  1245.             !("isClosing" in container.ownerWindow) &&
  1246.             lastViewCount > 0)
  1247.         {
  1248.             setTimeout (closeWindow, 1, container.ownerWindow);
  1249.             //dd ("} no children, closing window");
  1250.             return;
  1251.         }
  1252.     }
  1253.     else
  1254.     {
  1255.         //dd ("unhiding");
  1256.         container.removeAttribute("collapsed");
  1257.     }
  1258.  
  1259.     if (container.parentNode.localName == "viewcontainer")
  1260.         viewManager.groutContainer(container.parentNode);
  1261.  
  1262.     //dd ("} " + container.getAttribute("id") +
  1263.     //    " view count: " + container.viewCount);
  1264.  
  1265. }
  1266.  
  1267. ViewManager.prototype.findFloatingView =
  1268. function vmgr_findview (element)
  1269. {
  1270.     while (element && element.localName != "floatingview")
  1271.     {
  1272.         if (element.localName == "little-tab")
  1273.         {
  1274.             // this is probably a tab from a tab view container
  1275.             var container = element.parentNode.parentNode.parentNode;
  1276.             if (container.localName == "viewcontainer")
  1277.                 return container.childNodes[element.getAttribute("index")];
  1278.         }
  1279.         
  1280.         element = element.parentNode;
  1281.     }
  1282.     
  1283.     return element;
  1284. }
  1285.  
  1286. ViewManager.prototype.findViewTab =
  1287. function vmgr_findtab (viewContent)
  1288. {
  1289.     var container = viewContent.parentNode;
  1290.     if (!ASSERT (container.localName == "viewcontainer", "not part of a view"))
  1291.         return null;
  1292.     
  1293.     if (container.getAttribute("type") != "tab")
  1294.         return null;
  1295.     
  1296.     var len = container.childNodes.length;
  1297.     for (var i = 0; i < len; ++i)
  1298.     {
  1299.         if (container.childNodes[i] == viewContent)
  1300.             break;
  1301.     }
  1302.     
  1303.     if (!ASSERT(i < len, "view not in its container?"))
  1304.         return null;
  1305.     
  1306.     return container.tabs.childNodes[i];
  1307. }
  1308.  
  1309. ViewManager.prototype.getDropDirection =
  1310. function vmgr_getdropdir (event, floatingView)
  1311. {
  1312.     var eventX = event.screenX - floatingView.boxObject.screenX;
  1313.     var eventY = event.screenY - floatingView.boxObject.screenY;
  1314.     var viewW = floatingView.boxObject.width;
  1315.     var viewH = floatingView.boxObject.height;
  1316.  
  1317.     if ((event.target.localName == "image" &&
  1318.          event.target.getAttribute("class") == "view-title-pop"))
  1319.     {
  1320.         // dropping on the pop icon
  1321.         return "new-tab";
  1322.     }
  1323.     
  1324.     if (eventY > viewH)
  1325.     {
  1326.         // out of bounds we must be in the tab strip of a tab view
  1327.         var tab = this.findViewTab(floatingView);
  1328.         if (!ASSERT(tab, "view has no tab"))
  1329.             return "new-tab";
  1330.         
  1331.         if (event.screenX > tab.boxObject.screenX + (tab.boxObject.width / 2))
  1332.             return "next-tab";
  1333.         
  1334.         return "prev-tab";
  1335.     }
  1336.     
  1337.     var rv;
  1338.     var dir;
  1339.  
  1340.     var m = viewH / viewW;
  1341.     if (eventY < m * eventX)
  1342.         dir = -1;
  1343.     else
  1344.         dir = 1;
  1345.     
  1346.     m = -m;
  1347.     
  1348.     if (eventY < m * eventX + viewH)
  1349.     {
  1350.         if (dir < 0)
  1351.             rv = "up";
  1352.         else
  1353.             rv = "left";
  1354.     }
  1355.     else
  1356.     {
  1357.         if (dir < 0)
  1358.             rv = "right";
  1359.         else
  1360.             rv = "down";
  1361.     }
  1362.  
  1363.     return rv;
  1364. }
  1365.  
  1366. ViewManager.prototype.onDragStart =
  1367. function vmgr_dragstart (event, transferData, action)
  1368. {
  1369.     var floatingView = this.findFloatingView (event.originalTarget);
  1370.     if (!floatingView)
  1371.         return false;
  1372.     
  1373.     var viewId = floatingView.getAttribute("id");
  1374.     if (!ASSERT(viewId in this.views, "unknown view " + viewId))
  1375.         return false;
  1376.     
  1377.     var view = this.views[viewId];
  1378.     
  1379.     if (!ASSERT("currentContent" in view, "view is not visible " + viewId))
  1380.         return false;
  1381.     
  1382.     var locationURL = this.computeLocation (view.currentContent);
  1383.     transferData.data = new TransferData();
  1384.     transferData.data.addDataForFlavour("text/x-vloc", locationURL);
  1385.  
  1386.     return true;
  1387. }
  1388.  
  1389. ViewManager.prototype.getSupportedFlavours =
  1390. function vmgr_nicename ()
  1391. {
  1392.     var flavours = new FlavourSet();
  1393.     flavours.appendFlavour("text/x-vloc");
  1394.     return flavours;
  1395. }
  1396.  
  1397. ViewManager.prototype.onViewDragOver =
  1398. function vmgr_dragover (event, flavor, session)
  1399. {
  1400.     session.canDrop = false;
  1401.     
  1402.     if (flavor.contentType != "text/x-vloc")
  1403.         return false;
  1404.  
  1405.     var target = this.findFloatingView(event.originalTarget);
  1406.     if (!target)
  1407.         return false;
  1408.  
  1409.     /* COVER YOUR EYES!! */
  1410.     var data = nsTransferable.get (this.getSupportedFlavours(),
  1411.                                    nsDragAndDrop.getDragData, true);
  1412.     data = data.first.first;
  1413.     
  1414.     var parsedLocation = this.parseLocation(data.data);
  1415.     if (target.getAttribute("id") == parsedLocation.id)
  1416.         return false;
  1417.     
  1418.     var direction = this.getDropDirection(event, target);
  1419.  
  1420.     if (target.parentNode.getAttribute("type") == "tab" &&
  1421.         direction.indexOf("tab") == -1)
  1422.     {
  1423.         // for tab views, up, down, left, and right are relative to the
  1424.         // tab container, *not* the view itself.
  1425.         target.parentNode.setAttribute ("dragover", direction);
  1426.     }
  1427.     else
  1428.     {
  1429.         target.setAttribute ("dragover", direction);
  1430.         target.proxyIcon.setAttribute ("dragover", direction);
  1431.  
  1432.         var tab = this.findViewTab(target);
  1433.         if (tab)
  1434.             tab.setAttribute("dragover", direction);
  1435.     }
  1436.     
  1437.     session.canDrop = true;
  1438.     return true;
  1439. }
  1440.  
  1441. ViewManager.prototype.onViewDragExit =
  1442. function vmgr_dragexit (event, session)
  1443. {
  1444.     var target = this.findFloatingView(event.originalTarget);
  1445.     if (target)
  1446.     {
  1447.         if (target.parentNode.getAttribute("type") == "tab")
  1448.         {
  1449.             // for tab views, up, down, left, and right are relative to the
  1450.             // tab container, *not* the view itself.
  1451.             target.parentNode.removeAttribute ("dragover");
  1452.         }
  1453.         
  1454.         target.removeAttribute ("dragover");
  1455.         target.proxyIcon.removeAttribute ("dragover");
  1456.         var tab = this.findViewTab(target);
  1457.         if (tab)
  1458.             tab.removeAttribute("dragover");
  1459.     }
  1460. }
  1461.  
  1462. ViewManager.prototype.onViewDrop =
  1463. function vmgr_ondrop (event, transferData, session)
  1464. {
  1465.     var viewManager = this;
  1466.     
  1467.     function callProcessDrop ()
  1468.     {
  1469.         viewManager.processDrop (sourceView, targetView, direction);
  1470.     };
  1471.     
  1472.     var floatingView = this.findFloatingView (event.originalTarget);
  1473.     var viewId = floatingView.getAttribute ("id");
  1474.     var targetView = this.views[viewId];
  1475.     if (!ASSERT("currentContent" in targetView,
  1476.                 "view is not visible " + viewId))
  1477.     {
  1478.         return false;
  1479.     }
  1480.  
  1481.     var parsedSource = this.parseLocation(transferData.data);
  1482.     if (!ASSERT(parsedSource, "unable to parse " + transferData.data))
  1483.         return false;
  1484.     
  1485.     if (parsedSource.id == viewId)
  1486.     {
  1487.         //dd ("wanker");
  1488.         return false;
  1489.     }
  1490.  
  1491.     var sourceView = this.views[parsedSource.id];
  1492.     
  1493.     var direction = this.getDropDirection (event, floatingView);
  1494.  
  1495.     /* performing the actual drop action may involve moving DOM nodes
  1496.      * that are involved in the actual drag-drop operation.  Mozilla
  1497.      * doesn't like it when you do that before drag-drop is done, so we
  1498.      * call ourselves back on a timer, to allow the drag-drop wind down before
  1499.      * modifying the DOM.
  1500.      */
  1501.     setTimeout (callProcessDrop, 1);
  1502.     return true;
  1503. }
  1504.  
  1505. ViewManager.prototype.processDrop =
  1506. function vmgr_dewdropinn (sourceView, targetView, direction)
  1507. {    
  1508.     var viewManager = this;
  1509.  
  1510.     function reparent (child, type)
  1511.     {
  1512.         if (!ASSERT(child.parentNode.localName == "viewcontainer",
  1513.                     "can't reparent child with unknown parent"))
  1514.         {
  1515.             return null;
  1516.         }
  1517.         
  1518.         var childLocation = viewManager.computeLocation(child);
  1519.         var id = "vm-container-" + ++viewManager.containerSequence;
  1520.         while (child.ownerDocument.getElementById(id))
  1521.             id = "vm-container-" + ++viewManager.containerSequence;
  1522.         var container = viewManager.createContainer (childLocation, id, type);
  1523.         var newLocation = { windowId: parsedTarget.windowId, containerId: id };
  1524.  
  1525.         if (child.localName == "floatingview")
  1526.         {
  1527.             viewManager.moveView (newLocation, childLocation.id);
  1528.         }
  1529.         else
  1530.         {
  1531.             viewManager.moveContainer (newLocation, child);
  1532.         }    
  1533.             
  1534.         return container;
  1535.     };
  1536.  
  1537.     try {
  1538.         
  1539.     var destContainer;
  1540.     var destBefore;
  1541.     var currentContent   = targetView.currentContent;
  1542.     var parsedTarget     = this.computeLocation (currentContent);
  1543.     var currentContainer = currentContent.parentNode;
  1544.     var parentType       = currentContainer.getAttribute("type");
  1545.  
  1546.     this.startMultiMove();
  1547.  
  1548.     if (direction.search(/^(new|next|prev)-tab$/) == 0)
  1549.     {
  1550.         if (parentType != "tab")
  1551.             destContainer = reparent(currentContent, "tab");
  1552.         else
  1553.             destContainer = currentContainer;
  1554.  
  1555.         if (direction == "new-tab")
  1556.             destBefore = null;
  1557.         else if (direction == "prev-tab")
  1558.             destBefore = currentContent;
  1559.         else if (direction == "next-tab")
  1560.             destBefore = currentContent.nextSibling;
  1561.     }
  1562.     else
  1563.     {
  1564.         if (parentType == "tab")
  1565.         {
  1566.             // tab containers can't accept up, down, left, right drops
  1567.             // directly.  instead we defer to the tab container's container.
  1568.             currentContent = currentContainer;
  1569.             currentContainer = currentContainer.parentNode;
  1570.             if (!ASSERT(currentContainer.localName == "viewcontainer"))
  1571.             {
  1572.                 this.endMultiMove();
  1573.                 return;
  1574.             }
  1575.             parentType = currentContainer.getAttribute("type");
  1576.         }    
  1577.  
  1578.         if (parentType == "vertical")
  1579.         {
  1580.             switch (direction)
  1581.             {
  1582.                 case "up":
  1583.                     destContainer = currentContainer;
  1584.                     destBefore = currentContent;
  1585.                     break;
  1586.                     
  1587.                 case "down":
  1588.                     destContainer = currentContainer;
  1589.                     destBefore = currentContent.nextSibling;
  1590.                     if (destBefore && destBefore.hasAttribute("grout"))
  1591.                         destBefore = destBefore.nextSibling;
  1592.                     break;
  1593.                     
  1594.                 case "left":
  1595.                     destContainer = reparent (currentContent, "horizontal");
  1596.                     destBefore = currentContent;
  1597.                     break;
  1598.                     
  1599.                 case "right":
  1600.                     destContainer = reparent (currentContent, "horizontal");
  1601.                     break;
  1602.             }
  1603.         }
  1604.         else if (parentType == "horizontal")
  1605.         {
  1606.             switch (direction)
  1607.             {
  1608.                 case "up":
  1609.                     destContainer = reparent (currentContent, "vertical");
  1610.                     destBefore = currentContent;
  1611.                     break;
  1612.                     
  1613.                 case "down":
  1614.                     destContainer = reparent (currentContent, "vertical");
  1615.                     break;
  1616.                     
  1617.                 case "left":
  1618.                     destContainer = currentContainer;
  1619.                     destBefore = currentContent;
  1620.                     break;
  1621.                     
  1622.                 case "right":
  1623.                     destContainer = currentContainer;
  1624.                     destBefore = currentContent.nextSibling;
  1625.                     if (destBefore && destBefore.hasAttribute("grout"))
  1626.                         destBefore = destBefore.nextSibling;
  1627.                     break;
  1628.             }
  1629.         }
  1630.     }
  1631.     
  1632.     var dest = new Object();
  1633.     dest.windowId = parsedTarget.windowId;
  1634.     dest.containerId = destContainer.getAttribute ("id");
  1635.     dest.before = destBefore ? destBefore.getAttribute("id") : null;
  1636.     this.moveView(dest, sourceView.viewId);
  1637.     this.endMultiMove();
  1638.     
  1639.     }
  1640.     catch (ex)
  1641.     {
  1642.         dd("caught exception: " + ex);
  1643.         dd(formatException(ex));
  1644.     }
  1645. }
  1646.